home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / xmllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  27KB  |  1,071 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''A parser for XML, using the derived class as static DTD.'''
  5. import re
  6. import string
  7. import warnings
  8. warnings.warn('The xmllib module is obsolete.  Use xml.sax instead.', DeprecationWarning)
  9. del warnings
  10. version = '0.3'
  11.  
  12. class Error(RuntimeError):
  13.     pass
  14.  
  15. _S = '[ \t\r\n]+'
  16. _opS = '[ \t\r\n]*'
  17. _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'
  18. _QStr = '(?:\'[^\']*\'|"[^"]*")'
  19. illegal = re.compile('[^\t\r\n -~\xa0-\xff]')
  20. interesting = re.compile('[]&<]')
  21. amp = re.compile('&')
  22. ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')
  23. entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')
  24. charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')
  25. space = re.compile(_S + '$')
  26. newline = re.compile('\n')
  27. attrfind = re.compile(_S + '(?P<name>' + _Name + ')(' + _opS + '=' + _opS + '(?P<value>' + _QStr + '|[-a-zA-Z0-9.:+*%?!\\(\\)_#=~]+))?')
  28. starttagopen = re.compile('<' + _Name)
  29. starttagend = re.compile(_opS + '(?P<slash>/?)>')
  30. starttagmatch = re.compile('<(?P<tagname>' + _Name + ')(?P<attrs>(?:' + attrfind.pattern + ')*)' + starttagend.pattern)
  31. endtagopen = re.compile('</')
  32. endbracket = re.compile(_opS + '>')
  33. endbracketfind = re.compile('(?:[^>\'"]|' + _QStr + ')*>')
  34. tagfind = re.compile(_Name)
  35. cdataopen = re.compile('<!\\[CDATA\\[')
  36. cdataclose = re.compile('\\]\\]>')
  37. _SystemLiteral = '(?P<%s>' + _QStr + ')'
  38. _PublicLiteral = '(?P<%s>"[-\'\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|\'[-\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*\')'
  39. _ExternalId = '(?:SYSTEM|PUBLIC' + _S + _PublicLiteral % 'pubid' + ')' + _S + _SystemLiteral % 'syslit'
  40. doctype = re.compile('<!DOCTYPE' + _S + '(?P<name>' + _Name + ')(?:' + _S + _ExternalId + ')?' + _opS)
  41. xmldecl = re.compile('<\\?xml' + _S + 'version' + _opS + '=' + _opS + '(?P<version>' + _QStr + ')' + '(?:' + _S + 'encoding' + _opS + '=' + _opS + '(?P<encoding>\'[A-Za-z][-A-Za-z0-9._]*\'|"[A-Za-z][-A-Za-z0-9._]*"))?(?:' + _S + 'standalone' + _opS + '=' + _opS + '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?' + _opS + '\\?>')
  42. procopen = re.compile('<\\?(?P<proc>' + _Name + ')' + _opS)
  43. procclose = re.compile(_opS + '\\?>')
  44. commentopen = re.compile('<!--')
  45. commentclose = re.compile('-->')
  46. doubledash = re.compile('--')
  47. attrtrans = string.maketrans(' \r\n\t', '    ')
  48. _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'
  49. ncname = re.compile(_NCName + '$')
  50. qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?(?P<local>' + _NCName + ')$')
  51. xmlns = re.compile('xmlns(?::(?P<ncname>' + _NCName + '))?$')
  52.  
  53. class XMLParser:
  54.     attributes = { }
  55.     elements = { }
  56.     __accept_unquoted_attributes = 0
  57.     __accept_missing_endtag_name = 0
  58.     __map_case = 0
  59.     __accept_utf8 = 0
  60.     __translate_attribute_references = 1
  61.     
  62.     def __init__(self, **kw):
  63.         self._XMLParser__fixed = 0
  64.         if 'accept_unquoted_attributes' in kw:
  65.             self._XMLParser__accept_unquoted_attributes = kw['accept_unquoted_attributes']
  66.         
  67.         if 'accept_missing_endtag_name' in kw:
  68.             self._XMLParser__accept_missing_endtag_name = kw['accept_missing_endtag_name']
  69.         
  70.         if 'map_case' in kw:
  71.             self._XMLParser__map_case = kw['map_case']
  72.         
  73.         if 'accept_utf8' in kw:
  74.             self._XMLParser__accept_utf8 = kw['accept_utf8']
  75.         
  76.         if 'translate_attribute_references' in kw:
  77.             self._XMLParser__translate_attribute_references = kw['translate_attribute_references']
  78.         
  79.         self.reset()
  80.  
  81.     
  82.     def __fixelements(self):
  83.         self._XMLParser__fixed = 1
  84.         self.elements = { }
  85.         self._XMLParser__fixdict(self.__dict__)
  86.         self._XMLParser__fixclass(self.__class__)
  87.  
  88.     
  89.     def __fixclass(self, kl):
  90.         self._XMLParser__fixdict(kl.__dict__)
  91.         for k in kl.__bases__:
  92.             self._XMLParser__fixclass(k)
  93.         
  94.  
  95.     
  96.     def __fixdict(self, dict):
  97.         for key in dict.keys():
  98.             if key[:6] == 'start_':
  99.                 tag = key[6:]
  100.                 (start, end) = self.elements.get(tag, (None, None))
  101.                 if start is None:
  102.                     self.elements[tag] = (getattr(self, key), end)
  103.                 
  104.             start is None
  105.             if key[:4] == 'end_':
  106.                 tag = key[4:]
  107.                 (start, end) = self.elements.get(tag, (None, None))
  108.                 if end is None:
  109.                     self.elements[tag] = (start, getattr(self, key))
  110.                 
  111.             end is None
  112.         
  113.  
  114.     
  115.     def reset(self):
  116.         self.rawdata = ''
  117.         self.stack = []
  118.         self.nomoretags = 0
  119.         self.literal = 0
  120.         self.lineno = 1
  121.         self._XMLParser__at_start = 1
  122.         self._XMLParser__seen_doctype = None
  123.         self._XMLParser__seen_starttag = 0
  124.         self._XMLParser__use_namespaces = 0
  125.         self._XMLParser__namespaces = {
  126.             'xml': None }
  127.         if self.elements is XMLParser.elements:
  128.             self._XMLParser__fixelements()
  129.         
  130.  
  131.     
  132.     def setnomoretags(self):
  133.         self.nomoretags = self.literal = 1
  134.  
  135.     
  136.     def setliteral(self, *args):
  137.         self.literal = 1
  138.  
  139.     
  140.     def feed(self, data):
  141.         self.rawdata = self.rawdata + data
  142.         self.goahead(0)
  143.  
  144.     
  145.     def close(self):
  146.         self.goahead(1)
  147.         if self._XMLParser__fixed:
  148.             self._XMLParser__fixed = 0
  149.             del self.elements
  150.         
  151.  
  152.     
  153.     def translate_references(self, data, all = 1):
  154.         if not self._XMLParser__translate_attribute_references:
  155.             return data
  156.         
  157.         i = 0
  158.         while None:
  159.             res = amp.search(data, i)
  160.             if res is None:
  161.                 return data
  162.             
  163.             s = res.start(0)
  164.             res = ref.match(data, s)
  165.             if res is None:
  166.                 self.syntax_error("bogus `&'")
  167.                 i = s + 1
  168.                 continue
  169.             
  170.             i = res.end(0)
  171.             str = res.group(1)
  172.             rescan = 0
  173.             if str[0] == '#':
  174.                 if str[1] == 'x':
  175.                     str = chr(int(str[2:], 16))
  176.                 else:
  177.                     str = chr(int(str[1:]))
  178.                 if data[i - 1] != ';':
  179.                     self.syntax_error("`;' missing after char reference")
  180.                     i = i - 1
  181.                 
  182.             elif all:
  183.                 if str in self.entitydefs:
  184.                     str = self.entitydefs[str]
  185.                     rescan = 1
  186.                 elif data[i - 1] != ';':
  187.                     self.syntax_error("bogus `&'")
  188.                     i = s + 1
  189.                     continue
  190.                 else:
  191.                     self.syntax_error("reference to unknown entity `&%s;'" % str)
  192.                     str = '&' + str + ';'
  193.             elif data[i - 1] != ';':
  194.                 self.syntax_error("bogus `&'")
  195.                 i = s + 1
  196.                 continue
  197.             
  198.             data = data[:s] + str + data[i:]
  199.             if rescan:
  200.                 i = s
  201.                 continue
  202.             i = s + len(str)
  203.             continue
  204.             return None
  205.  
  206.     
  207.     def getnamespace(self):
  208.         nsdict = { }
  209.         for t, d, nst in self.stack:
  210.             nsdict.update(d)
  211.         
  212.         return nsdict
  213.  
  214.     
  215.     def goahead(self, end):
  216.         rawdata = self.rawdata
  217.         i = 0
  218.         n = len(rawdata)
  219.         while i < n:
  220.             if i > 0:
  221.                 self._XMLParser__at_start = 0
  222.             
  223.             if self.nomoretags:
  224.                 data = rawdata[i:n]
  225.                 self.handle_data(data)
  226.                 self.lineno = self.lineno + data.count('\n')
  227.                 i = n
  228.                 break
  229.             
  230.             res = interesting.search(rawdata, i)
  231.             if res:
  232.                 j = res.start(0)
  233.             else:
  234.                 j = n
  235.             if i < j:
  236.                 data = rawdata[i:j]
  237.                 if self._XMLParser__at_start and space.match(data) is None:
  238.                     self.syntax_error('illegal data at start of file')
  239.                 
  240.                 self._XMLParser__at_start = 0
  241.                 if not (self.stack) and space.match(data) is None:
  242.                     self.syntax_error('data not in content')
  243.                 
  244.                 if not (self._XMLParser__accept_utf8) and illegal.search(data):
  245.                     self.syntax_error('illegal character in content')
  246.                 
  247.                 self.handle_data(data)
  248.                 self.lineno = self.lineno + data.count('\n')
  249.             
  250.             i = j
  251.             if i == n:
  252.                 break
  253.             
  254.             if rawdata[i] == '<':
  255.                 if starttagopen.match(rawdata, i):
  256.                     if self.literal:
  257.                         data = rawdata[i]
  258.                         self.handle_data(data)
  259.                         self.lineno = self.lineno + data.count('\n')
  260.                         i = i + 1
  261.                         continue
  262.                     
  263.                     k = self.parse_starttag(i)
  264.                     if k < 0:
  265.                         break
  266.                     
  267.                     self._XMLParser__seen_starttag = 1
  268.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  269.                     i = k
  270.                     continue
  271.                 
  272.                 if endtagopen.match(rawdata, i):
  273.                     k = self.parse_endtag(i)
  274.                     if k < 0:
  275.                         break
  276.                     
  277.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  278.                     i = k
  279.                     continue
  280.                 
  281.                 if commentopen.match(rawdata, i):
  282.                     if self.literal:
  283.                         data = rawdata[i]
  284.                         self.handle_data(data)
  285.                         self.lineno = self.lineno + data.count('\n')
  286.                         i = i + 1
  287.                         continue
  288.                     
  289.                     k = self.parse_comment(i)
  290.                     if k < 0:
  291.                         break
  292.                     
  293.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  294.                     i = k
  295.                     continue
  296.                 
  297.                 if cdataopen.match(rawdata, i):
  298.                     k = self.parse_cdata(i)
  299.                     if k < 0:
  300.                         break
  301.                     
  302.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  303.                     i = k
  304.                     continue
  305.                 
  306.                 res = xmldecl.match(rawdata, i)
  307.                 if res:
  308.                     if not self._XMLParser__at_start:
  309.                         self.syntax_error('<?xml?> declaration not at start of document')
  310.                     
  311.                     (version, encoding, standalone) = res.group('version', 'encoding', 'standalone')
  312.                     if version[1:-1] != '1.0':
  313.                         raise Error('only XML version 1.0 supported')
  314.                     
  315.                     if encoding:
  316.                         encoding = encoding[1:-1]
  317.                     
  318.                     if standalone:
  319.                         standalone = standalone[1:-1]
  320.                     
  321.                     self.handle_xml(encoding, standalone)
  322.                     i = res.end(0)
  323.                     continue
  324.                 
  325.                 res = procopen.match(rawdata, i)
  326.                 if res:
  327.                     k = self.parse_proc(i)
  328.                     if k < 0:
  329.                         break
  330.                     
  331.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  332.                     i = k
  333.                     continue
  334.                 
  335.                 res = doctype.match(rawdata, i)
  336.                 if res:
  337.                     if self.literal:
  338.                         data = rawdata[i]
  339.                         self.handle_data(data)
  340.                         self.lineno = self.lineno + data.count('\n')
  341.                         i = i + 1
  342.                         continue
  343.                     
  344.                     if self._XMLParser__seen_doctype:
  345.                         self.syntax_error('multiple DOCTYPE elements')
  346.                     
  347.                     if self._XMLParser__seen_starttag:
  348.                         self.syntax_error('DOCTYPE not at beginning of document')
  349.                     
  350.                     k = self.parse_doctype(res)
  351.                     if k < 0:
  352.                         break
  353.                     
  354.                     self._XMLParser__seen_doctype = res.group('name')
  355.                     if self._XMLParser__map_case:
  356.                         self._XMLParser__seen_doctype = self._XMLParser__seen_doctype.lower()
  357.                     
  358.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  359.                     i = k
  360.                     continue
  361.                 
  362.             elif rawdata[i] == '&':
  363.                 if self.literal:
  364.                     data = rawdata[i]
  365.                     self.handle_data(data)
  366.                     i = i + 1
  367.                     continue
  368.                 
  369.                 res = charref.match(rawdata, i)
  370.                 if res is not None:
  371.                     i = res.end(0)
  372.                     if rawdata[i - 1] != ';':
  373.                         self.syntax_error("`;' missing in charref")
  374.                         i = i - 1
  375.                     
  376.                     if not self.stack:
  377.                         self.syntax_error('data not in content')
  378.                     
  379.                     self.handle_charref(res.group('char')[:-1])
  380.                     self.lineno = self.lineno + res.group(0).count('\n')
  381.                     continue
  382.                 
  383.                 res = entityref.match(rawdata, i)
  384.                 if res is not None:
  385.                     i = res.end(0)
  386.                     if rawdata[i - 1] != ';':
  387.                         self.syntax_error("`;' missing in entityref")
  388.                         i = i - 1
  389.                     
  390.                     name = res.group('name')
  391.                     if self._XMLParser__map_case:
  392.                         name = name.lower()
  393.                     
  394.                     if name in self.entitydefs:
  395.                         self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]
  396.                         n = len(rawdata)
  397.                         i = res.start(0)
  398.                     else:
  399.                         self.unknown_entityref(name)
  400.                     self.lineno = self.lineno + res.group(0).count('\n')
  401.                     continue
  402.                 
  403.             elif rawdata[i] == ']':
  404.                 if self.literal:
  405.                     data = rawdata[i]
  406.                     self.handle_data(data)
  407.                     i = i + 1
  408.                     continue
  409.                 
  410.                 if n - i < 3:
  411.                     break
  412.                 
  413.                 if cdataclose.match(rawdata, i):
  414.                     self.syntax_error("bogus `]]>'")
  415.                 
  416.                 self.handle_data(rawdata[i])
  417.                 i = i + 1
  418.                 continue
  419.             else:
  420.                 raise Error('neither < nor & ??')
  421.             break
  422.         if i > 0:
  423.             self._XMLParser__at_start = 0
  424.         
  425.         if end and i < n:
  426.             data = rawdata[i]
  427.             self.syntax_error("bogus `%s'" % data)
  428.             if not (self._XMLParser__accept_utf8) and illegal.search(data):
  429.                 self.syntax_error('illegal character in content')
  430.             
  431.             self.handle_data(data)
  432.             self.lineno = self.lineno + data.count('\n')
  433.             self.rawdata = rawdata[i + 1:]
  434.             return self.goahead(end)
  435.         
  436.         self.rawdata = rawdata[i:]
  437.         if end:
  438.             if not self._XMLParser__seen_starttag:
  439.                 self.syntax_error('no elements in file')
  440.             
  441.             if self.stack:
  442.                 self.syntax_error('missing end tags')
  443.                 while self.stack:
  444.                     self.finish_endtag(self.stack[-1][0])
  445.             
  446.         
  447.  
  448.     
  449.     def parse_comment(self, i):
  450.         rawdata = self.rawdata
  451.         if rawdata[i:i + 4] != '<!--':
  452.             raise Error('unexpected call to handle_comment')
  453.         
  454.         res = commentclose.search(rawdata, i + 4)
  455.         if res is None:
  456.             return -1
  457.         
  458.         if doubledash.search(rawdata, i + 4, res.start(0)):
  459.             self.syntax_error("`--' inside comment")
  460.         
  461.         if rawdata[res.start(0) - 1] == '-':
  462.             self.syntax_error('comment cannot end in three dashes')
  463.         
  464.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 4, res.start(0)):
  465.             self.syntax_error('illegal character in comment')
  466.         
  467.         self.handle_comment(rawdata[i + 4:res.start(0)])
  468.         return res.end(0)
  469.  
  470.     
  471.     def parse_doctype(self, res):
  472.         rawdata = self.rawdata
  473.         n = len(rawdata)
  474.         name = res.group('name')
  475.         if self._XMLParser__map_case:
  476.             name = name.lower()
  477.         
  478.         (pubid, syslit) = res.group('pubid', 'syslit')
  479.         if pubid is not None:
  480.             pubid = pubid[1:-1]
  481.             pubid = ' '.join(pubid.split())
  482.         
  483.         if syslit is not None:
  484.             syslit = syslit[1:-1]
  485.         
  486.         j = k = res.end(0)
  487.         if k >= n:
  488.             return -1
  489.         
  490.         if rawdata[k] == '[':
  491.             level = 0
  492.             k = k + 1
  493.             dq = sq = 0
  494.             while k < n:
  495.                 c = rawdata[k]
  496.                 if not sq and c == '"':
  497.                     dq = not dq
  498.                 elif not dq and c == "'":
  499.                     sq = not sq
  500.                 elif sq or dq:
  501.                     pass
  502.                 elif level <= 0 and c == ']':
  503.                     res = endbracket.match(rawdata, k + 1)
  504.                     if res is None:
  505.                         return -1
  506.                     
  507.                     self.handle_doctype(name, pubid, syslit, rawdata[j + 1:k])
  508.                     return res.end(0)
  509.                 elif c == '<':
  510.                     level = level + 1
  511.                 elif c == '>':
  512.                     level = level - 1
  513.                     if level < 0:
  514.                         self.syntax_error("bogus `>' in DOCTYPE")
  515.                     
  516.                 
  517.                 k = k + 1
  518.         
  519.         res = endbracketfind.match(rawdata, k)
  520.         if res is None:
  521.             return -1
  522.         
  523.         if endbracket.match(rawdata, k) is None:
  524.             self.syntax_error('garbage in DOCTYPE')
  525.         
  526.         self.handle_doctype(name, pubid, syslit, None)
  527.         return res.end(0)
  528.  
  529.     
  530.     def parse_cdata(self, i):
  531.         rawdata = self.rawdata
  532.         if rawdata[i:i + 9] != '<![CDATA[':
  533.             raise Error('unexpected call to parse_cdata')
  534.         
  535.         res = cdataclose.search(rawdata, i + 9)
  536.         if res is None:
  537.             return -1
  538.         
  539.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 9, res.start(0)):
  540.             self.syntax_error('illegal character in CDATA')
  541.         
  542.         if not self.stack:
  543.             self.syntax_error('CDATA not in content')
  544.         
  545.         self.handle_cdata(rawdata[i + 9:res.start(0)])
  546.         return res.end(0)
  547.  
  548.     __xml_namespace_attributes = {
  549.         'ns': None,
  550.         'src': None,
  551.         'prefix': None }
  552.     
  553.     def parse_proc(self, i):
  554.         rawdata = self.rawdata
  555.         end = procclose.search(rawdata, i)
  556.         if end is None:
  557.             return -1
  558.         
  559.         j = end.start(0)
  560.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 2, j):
  561.             self.syntax_error('illegal character in processing instruction')
  562.         
  563.         res = tagfind.match(rawdata, i + 2)
  564.         if res is None:
  565.             raise Error('unexpected call to parse_proc')
  566.         
  567.         k = res.end(0)
  568.         name = res.group(0)
  569.         if self._XMLParser__map_case:
  570.             name = name.lower()
  571.         
  572.         if name == 'xml:namespace':
  573.             self.syntax_error('old-fashioned namespace declaration')
  574.             self._XMLParser__use_namespaces = -1
  575.             if self._XMLParser__seen_doctype or self._XMLParser__seen_starttag:
  576.                 self.syntax_error('xml:namespace declaration too late in document')
  577.             
  578.             (attrdict, namespace, k) = self.parse_attributes(name, k, j)
  579.             if namespace:
  580.                 self.syntax_error('namespace declaration inside namespace declaration')
  581.             
  582.             for attrname in attrdict.keys():
  583.                 if attrname not in self._XMLParser__xml_namespace_attributes:
  584.                     self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)
  585.                     continue
  586.             
  587.             if 'ns' not in attrdict or 'prefix' not in attrdict:
  588.                 self.syntax_error('xml:namespace without required attributes')
  589.             
  590.             prefix = attrdict.get('prefix')
  591.             if ncname.match(prefix) is None:
  592.                 self.syntax_error('xml:namespace illegal prefix value')
  593.                 return end.end(0)
  594.             
  595.             if prefix in self._XMLParser__namespaces:
  596.                 self.syntax_error('xml:namespace prefix not unique')
  597.             
  598.             self._XMLParser__namespaces[prefix] = attrdict['ns']
  599.         elif name.lower() == 'xml':
  600.             self.syntax_error('illegal processing instruction target name')
  601.         
  602.         self.handle_proc(name, rawdata[k:j])
  603.         return end.end(0)
  604.  
  605.     
  606.     def parse_attributes(self, tag, i, j):
  607.         rawdata = self.rawdata
  608.         attrdict = { }
  609.         namespace = { }
  610.         while i < j:
  611.             res = attrfind.match(rawdata, i)
  612.             if res is None:
  613.                 break
  614.             
  615.             (attrname, attrvalue) = res.group('name', 'value')
  616.             if self._XMLParser__map_case:
  617.                 attrname = attrname.lower()
  618.             
  619.             i = res.end(0)
  620.             if attrvalue is None:
  621.                 self.syntax_error("no value specified for attribute `%s'" % attrname)
  622.                 attrvalue = attrname
  623.             elif "'" == "'":
  624.                 pass
  625.             elif not "'" == attrvalue[-1:]:
  626.                 if '"' == '"':
  627.                     pass
  628.                 elif '"' == attrvalue[-1:]:
  629.                     attrvalue = attrvalue[1:-1]
  630.                 elif not self._XMLParser__accept_unquoted_attributes:
  631.                     self.syntax_error("attribute `%s' value not quoted" % attrname)
  632.                 
  633.             res = xmlns.match(attrname)
  634.             if res is not None:
  635.                 ncname = res.group('ncname')
  636.                 None[namespace if not attrvalue else ''] = None
  637.                 if not self._XMLParser__use_namespaces:
  638.                     self._XMLParser__use_namespaces = len(self.stack) + 1
  639.                     continue
  640.                 continue
  641.             
  642.             if '<' in attrvalue:
  643.                 self.syntax_error("`<' illegal in attribute value")
  644.             
  645.             if attrname in attrdict:
  646.                 self.syntax_error("attribute `%s' specified twice" % attrname)
  647.             
  648.             attrvalue = attrvalue.translate(attrtrans)
  649.             attrdict[attrname] = self.translate_references(attrvalue)
  650.         return (attrdict, namespace, i)
  651.  
  652.     
  653.     def parse_starttag(self, i):
  654.         rawdata = self.rawdata
  655.         end = endbracketfind.match(rawdata, i + 1)
  656.         if end is None:
  657.             return -1
  658.         
  659.         tag = starttagmatch.match(rawdata, i)
  660.         if tag is None or tag.end(0) != end.end(0):
  661.             self.syntax_error('garbage in starttag')
  662.             return end.end(0)
  663.         
  664.         nstag = tagname = tag.group('tagname')
  665.         if self._XMLParser__map_case:
  666.             nstag = tagname = nstag.lower()
  667.         
  668.         if not (self._XMLParser__seen_starttag) and self._XMLParser__seen_doctype and tagname != self._XMLParser__seen_doctype:
  669.             self.syntax_error('starttag does not match DOCTYPE')
  670.         
  671.         if self._XMLParser__seen_starttag and not (self.stack):
  672.             self.syntax_error('multiple elements on top level')
  673.         
  674.         (k, j) = tag.span('attrs')
  675.         (attrdict, nsdict, k) = self.parse_attributes(tagname, k, j)
  676.         self.stack.append((tagname, nsdict, nstag))
  677.         if self._XMLParser__use_namespaces:
  678.             res = qname.match(tagname)
  679.         else:
  680.             res = None
  681.         if res is not None:
  682.             (prefix, nstag) = res.group('prefix', 'local')
  683.             if prefix is None:
  684.                 prefix = ''
  685.             
  686.             ns = None
  687.             for t, d, nst in self.stack:
  688.                 if prefix in d:
  689.                     ns = d[prefix]
  690.                     continue
  691.             
  692.             if ns is None and prefix != '':
  693.                 ns = self._XMLParser__namespaces.get(prefix)
  694.             
  695.             if ns is not None:
  696.                 nstag = ns + ' ' + nstag
  697.             elif prefix != '':
  698.                 nstag = prefix + ':' + nstag
  699.             
  700.             self.stack[-1] = (tagname, nsdict, nstag)
  701.         
  702.         attrnamemap = { }
  703.         for key in attrdict.keys():
  704.             attrnamemap[key] = key
  705.         
  706.         if self._XMLParser__use_namespaces:
  707.             nattrdict = { }
  708.             for key, val in attrdict.items():
  709.                 okey = key
  710.                 res = qname.match(key)
  711.                 if res is not None:
  712.                     (aprefix, key) = res.group('prefix', 'local')
  713.                     if self._XMLParser__map_case:
  714.                         key = key.lower()
  715.                     
  716.                     if aprefix is not None:
  717.                         ans = None
  718.                         for t, d, nst in self.stack:
  719.                             if aprefix in d:
  720.                                 ans = d[aprefix]
  721.                                 continue
  722.                         
  723.                         if ans is None:
  724.                             ans = self._XMLParser__namespaces.get(aprefix)
  725.                         
  726.                         if ans is not None:
  727.                             key = ans + ' ' + key
  728.                         else:
  729.                             key = aprefix + ':' + key
  730.                     
  731.                 
  732.                 nattrdict[key] = val
  733.                 attrnamemap[key] = okey
  734.             
  735.             attrdict = nattrdict
  736.         
  737.         attributes = self.attributes.get(nstag)
  738.         if attributes is not None:
  739.             for key in attrdict.keys():
  740.                 if key not in attributes:
  741.                     self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))
  742.                     continue
  743.             
  744.             for key, val in attributes.items():
  745.                 if val is not None and key not in attrdict:
  746.                     attrdict[key] = val
  747.                     continue
  748.             
  749.         
  750.         method = self.elements.get(nstag, (None, None))[0]
  751.         self.finish_starttag(nstag, attrdict, method)
  752.         if tag.group('slash') == '/':
  753.             self.finish_endtag(tagname)
  754.         
  755.         return tag.end(0)
  756.  
  757.     
  758.     def parse_endtag(self, i):
  759.         rawdata = self.rawdata
  760.         end = endbracketfind.match(rawdata, i + 1)
  761.         if end is None:
  762.             return -1
  763.         
  764.         res = tagfind.match(rawdata, i + 2)
  765.         if res is None:
  766.             if self.literal:
  767.                 self.handle_data(rawdata[i])
  768.                 return i + 1
  769.             
  770.             if not self._XMLParser__accept_missing_endtag_name:
  771.                 self.syntax_error('no name specified in end tag')
  772.             
  773.             tag = self.stack[-1][0]
  774.             k = i + 2
  775.         else:
  776.             tag = res.group(0)
  777.             if self._XMLParser__map_case:
  778.                 tag = tag.lower()
  779.             
  780.             if self.literal:
  781.                 if not (self.stack) or tag != self.stack[-1][0]:
  782.                     self.handle_data(rawdata[i])
  783.                     return i + 1
  784.                 
  785.             
  786.             k = res.end(0)
  787.         if endbracket.match(rawdata, k) is None:
  788.             self.syntax_error('garbage in end tag')
  789.         
  790.         self.finish_endtag(tag)
  791.         return end.end(0)
  792.  
  793.     
  794.     def finish_starttag(self, tagname, attrdict, method):
  795.         if method is not None:
  796.             self.handle_starttag(tagname, method, attrdict)
  797.         else:
  798.             self.unknown_starttag(tagname, attrdict)
  799.  
  800.     
  801.     def finish_endtag(self, tag):
  802.         self.literal = 0
  803.         if not tag:
  804.             self.syntax_error('name-less end tag')
  805.             found = len(self.stack) - 1
  806.             if found < 0:
  807.                 self.unknown_endtag(tag)
  808.                 return None
  809.             
  810.         else:
  811.             found = -1
  812.             for i in range(len(self.stack)):
  813.                 if tag == self.stack[i][0]:
  814.                     found = i
  815.                     continue
  816.             
  817.             if found == -1:
  818.                 self.syntax_error('unopened end tag')
  819.                 return None
  820.             
  821.         while len(self.stack) > found:
  822.             if found < len(self.stack) - 1:
  823.                 self.syntax_error('missing close tag for %s' % self.stack[-1][2])
  824.             
  825.             nstag = self.stack[-1][2]
  826.             method = self.elements.get(nstag, (None, None))[1]
  827.             if method is not None:
  828.                 self.handle_endtag(nstag, method)
  829.             else:
  830.                 self.unknown_endtag(nstag)
  831.             if self._XMLParser__use_namespaces == len(self.stack):
  832.                 self._XMLParser__use_namespaces = 0
  833.             
  834.             del self.stack[-1]
  835.  
  836.     
  837.     def handle_xml(self, encoding, standalone):
  838.         pass
  839.  
  840.     
  841.     def handle_doctype(self, tag, pubid, syslit, data):
  842.         pass
  843.  
  844.     
  845.     def handle_starttag(self, tag, method, attrs):
  846.         method(attrs)
  847.  
  848.     
  849.     def handle_endtag(self, tag, method):
  850.         method()
  851.  
  852.     
  853.     def handle_charref(self, name):
  854.         
  855.         try:
  856.             if name[0] == 'x':
  857.                 n = int(name[1:], 16)
  858.             else:
  859.                 n = int(name)
  860.         except ValueError:
  861.             self.unknown_charref(name)
  862.             return None
  863.  
  864.         if n <= n:
  865.             pass
  866.         elif not n <= 255:
  867.             self.unknown_charref(name)
  868.             return None
  869.         
  870.         self.handle_data(chr(n))
  871.  
  872.     entitydefs = {
  873.         'lt': '<',
  874.         'gt': '>',
  875.         'amp': '&',
  876.         'quot': '"',
  877.         'apos': ''' }
  878.     
  879.     def handle_data(self, data):
  880.         pass
  881.  
  882.     
  883.     def handle_cdata(self, data):
  884.         pass
  885.  
  886.     
  887.     def handle_comment(self, data):
  888.         pass
  889.  
  890.     
  891.     def handle_proc(self, name, data):
  892.         pass
  893.  
  894.     
  895.     def syntax_error(self, message):
  896.         raise Error('Syntax error at line %d: %s' % (self.lineno, message))
  897.  
  898.     
  899.     def unknown_starttag(self, tag, attrs):
  900.         pass
  901.  
  902.     
  903.     def unknown_endtag(self, tag):
  904.         pass
  905.  
  906.     
  907.     def unknown_charref(self, ref):
  908.         pass
  909.  
  910.     
  911.     def unknown_entityref(self, name):
  912.         self.syntax_error("reference to unknown entity `&%s;'" % name)
  913.  
  914.  
  915.  
  916. class TestXMLParser(XMLParser):
  917.     
  918.     def __init__(self, **kw):
  919.         self.testdata = ''
  920.         XMLParser.__init__(self, **kw)
  921.  
  922.     
  923.     def handle_xml(self, encoding, standalone):
  924.         self.flush()
  925.         print 'xml: encoding =', encoding, 'standalone =', standalone
  926.  
  927.     
  928.     def handle_doctype(self, tag, pubid, syslit, data):
  929.         self.flush()
  930.         print 'DOCTYPE:', tag, repr(data)
  931.  
  932.     
  933.     def handle_data(self, data):
  934.         self.testdata = self.testdata + data
  935.         if len(repr(self.testdata)) >= 70:
  936.             self.flush()
  937.         
  938.  
  939.     
  940.     def flush(self):
  941.         data = self.testdata
  942.         if data:
  943.             self.testdata = ''
  944.             print 'data:', repr(data)
  945.         
  946.  
  947.     
  948.     def handle_cdata(self, data):
  949.         self.flush()
  950.         print 'cdata:', repr(data)
  951.  
  952.     
  953.     def handle_proc(self, name, data):
  954.         self.flush()
  955.         print 'processing:', name, repr(data)
  956.  
  957.     
  958.     def handle_comment(self, data):
  959.         self.flush()
  960.         r = repr(data)
  961.         if len(r) > 68:
  962.             r = r[:32] + '...' + r[-32:]
  963.         
  964.         print 'comment:', r
  965.  
  966.     
  967.     def syntax_error(self, message):
  968.         print 'error at line %d:' % self.lineno, message
  969.  
  970.     
  971.     def unknown_starttag(self, tag, attrs):
  972.         self.flush()
  973.         if not attrs:
  974.             print 'start tag: <' + tag + '>'
  975.         else:
  976.             print 'start tag: <' + tag,
  977.             for name, value in attrs.items():
  978.                 print name + '=' + '"' + value + '"',
  979.             
  980.             print '>'
  981.  
  982.     
  983.     def unknown_endtag(self, tag):
  984.         self.flush()
  985.         print 'end tag: </' + tag + '>'
  986.  
  987.     
  988.     def unknown_entityref(self, ref):
  989.         self.flush()
  990.         print '*** unknown entity ref: &' + ref + ';'
  991.  
  992.     
  993.     def unknown_charref(self, ref):
  994.         self.flush()
  995.         print '*** unknown char ref: &#' + ref + ';'
  996.  
  997.     
  998.     def close(self):
  999.         XMLParser.close(self)
  1000.         self.flush()
  1001.  
  1002.  
  1003.  
  1004. def test(args = None):
  1005.     import sys as sys
  1006.     import getopt as getopt
  1007.     time = time
  1008.     import time
  1009.     if not args:
  1010.         args = sys.argv[1:]
  1011.     
  1012.     (opts, args) = getopt.getopt(args, 'st')
  1013.     klass = TestXMLParser
  1014.     do_time = 0
  1015.     for o, a in opts:
  1016.         if o == '-s':
  1017.             klass = XMLParser
  1018.             continue
  1019.         if o == '-t':
  1020.             do_time = 1
  1021.             continue
  1022.     
  1023.     if args:
  1024.         file = args[0]
  1025.     else:
  1026.         file = 'test.xml'
  1027.     if file == '-':
  1028.         f = sys.stdin
  1029.     else:
  1030.         
  1031.         try:
  1032.             f = open(file, 'r')
  1033.         except IOError:
  1034.             msg = None
  1035.             print file, ':', msg
  1036.             sys.exit(1)
  1037.  
  1038.     data = f.read()
  1039.     if f is not sys.stdin:
  1040.         f.close()
  1041.     
  1042.     x = klass()
  1043.     t0 = time()
  1044.     
  1045.     try:
  1046.         if do_time:
  1047.             x.feed(data)
  1048.             x.close()
  1049.         else:
  1050.             for c in data:
  1051.                 x.feed(c)
  1052.             
  1053.             x.close()
  1054.     except Error:
  1055.         msg = None
  1056.         t1 = time()
  1057.         print msg
  1058.         if do_time:
  1059.             print 'total time: %g' % (t1 - t0)
  1060.         
  1061.         sys.exit(1)
  1062.  
  1063.     t1 = time()
  1064.     if do_time:
  1065.         print 'total time: %g' % (t1 - t0)
  1066.     
  1067.  
  1068. if __name__ == '__main__':
  1069.     test()
  1070.  
  1071.